{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "import os\n",
    "import platform\n",
    "import pdb\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from matplotlib.pyplot import cm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=pd.read_csv('shenyang.csv')\n",
    "dataset=data.iloc[:,-1]\n",
    "dataset.replace(9999,np.nan,inplace=True)\n",
    "dataset.replace(-999,np.nan,inplace=True)\n",
    "for i in range(len(data)):\n",
    "    if np.isnan(dataset.iat[i]):\n",
    "        if i==0:\n",
    "            dataset.iloc[i]=dataset.iat[i+1]\n",
    "        elif i==len(data)-1:\n",
    "            dataset.iloc[i]=dataset.iat[i-1]\n",
    "        else:\n",
    "            dataset.iloc[i]=np.nanmean([dataset.iat[i-1],dataset.iat[i+1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.MinMaxScaler() \n",
    "scaled_values = scaler.fit_transform(pd.DataFrame(dataset))\n",
    "# dataset.iloc[:] = np.squeeze(scaled_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_set=np.asarray(dataset,dtype=np.float32)\n",
    "seq_len=30 + 1\n",
    "x=len(data_set)-seq_len\n",
    "sequences = [data_set[t:t+seq_len] for t in range(x)]\n",
    "for i in range(len(sequences)):\n",
    "    sequences[i]=scaler.fit_transform(sequences[i].reshape(-1,1))\n",
    "seq=torch.FloatTensor(sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_row=round(0.90*seq.size(0))\n",
    "x_train_set=seq[:split_row, :-1]\n",
    "y_train_set=seq[:split_row, -1]\n",
    "x_valid_set=seq[split_row:, :-1]\n",
    "y_valid_set=seq[split_row:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size,num_layers=2,dropout=0,bidirectional=False):\n",
    "        super(LSTM,self).__init__()\n",
    "        self.input_size=input_size\n",
    "        self.hidden_size=hidden_size\n",
    "        self.num_layers=num_layers\n",
    "        self.dropout=dropout\n",
    "        self.bidirectional=bidirectional\n",
    "        self.lstm = nn.LSTM(input_size,\n",
    "                            hidden_size,\n",
    "                            num_layers,\n",
    "                            dropout=dropout,\n",
    "                            bidirectional=bidirectional)\n",
    "        self.linear = nn.Linear(hidden_size, input_size)\n",
    "        \n",
    "    def forward(self,inputs,hidden):\n",
    "        outputs,hidden=self.lstm(inputs,hidden)\n",
    "        predictions=self.linear(outputs[-1])\n",
    "        return predictions,outputs,hidden\n",
    "    \n",
    "    def init_hidden(self,batch_size):\n",
    "        num_directions=2 if self.bidirectional else 1\n",
    "        hidden = (torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size),\n",
    "                  torch.zeros(self.num_layers*num_directions, batch_size, self.hidden_size))\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_batch(x,y,i,batch_size):\n",
    "    if x.dim() == 2:\n",
    "        x = x.unsqueeze(2)\n",
    "    batch_x = x[(i*batch_size):(i*batch_size)+batch_size, :, :]\n",
    "    batch_y = y[(i*batch_size):(i*batch_size)+batch_size]\n",
    "\n",
    "    # Reshape Tensors into (seq_len, batch_size, input_size) format for the LSTM.\n",
    "    batch_x = batch_x.transpose(0, 1)\n",
    "    \n",
    "    return batch_x, batch_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model,x_train_set,y_train_set,optimizer,batch_size,epoch):\n",
    "    num_sequences=x_train_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.train()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_train_set, y_train_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "        \n",
    "    print(\"Epoch {}: Loss = {:.8f}\".format(epoch+1, total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(model,x_valid_set,y_valid_set,optimizer,batch_size):\n",
    "    num_sequences=x_valid_set.size(0)\n",
    "    num_batches=num_sequences//batch_size\n",
    "    \n",
    "    total_loss=0\n",
    "    \n",
    "    model.eval()\n",
    "    for i in range(num_batches):\n",
    "        # Get input and target batches and reshape for LSTM.\n",
    "        batch_x, batch_y = get_batch(x_valid_set, y_valid_set, i, batch_size)\n",
    "\n",
    "        # Reset the gradient.\n",
    "        lstm.zero_grad()\n",
    "        \n",
    "        # Initialize the hidden states (see the function lstm.init_hidden(batch_size)).\n",
    "        hidden = lstm.init_hidden(batch_size)\n",
    "        \n",
    "        # Complete a forward pass.\n",
    "        y_pred, outputs, hidden = lstm(batch_x,hidden)\n",
    "        \n",
    "        # Calculate the loss with the 'loss_fn'.\n",
    "        loss = loss_fn(y_pred,batch_y)\n",
    "        \n",
    "        # Compute the gradient.\n",
    "        loss.backward()\n",
    "        \n",
    "        # Clip to the gradient to avoid exploding gradient.\n",
    "        nn.utils.clip_grad_norm_(lstm.parameters(), max_grad_norm)\n",
    "\n",
    "        # Make one step with optimizer.\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Accumulate the total loss.\n",
    "        total_loss += loss.data\n",
    "\n",
    "    print(\"Validation: Loss = {:.8f}\".format(total_loss/num_batches))\n",
    "    return total_loss/num_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(epoch, model, path='./'):\n",
    "    \n",
    "    # file name and path \n",
    "    filename = path + 'shenyang.pt'\n",
    "    \n",
    "    # load the model parameters \n",
    "    torch.save(model.state_dict(), filename)\n",
    "    \n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model for 30 epoch\n",
      "Epoch 1: Loss = 0.11047594\n",
      "Validation: Loss = 0.08083630\n",
      "Epoch 2: Loss = 0.07322289\n",
      "Validation: Loss = 0.06615975\n",
      "Epoch 3: Loss = 0.05786100\n",
      "Validation: Loss = 0.05571733\n",
      "Epoch 4: Loss = 0.04780668\n",
      "Validation: Loss = 0.04853429\n",
      "Epoch 5: Loss = 0.04018432\n",
      "Validation: Loss = 0.04381941\n",
      "Epoch 6: Loss = 0.03577261\n",
      "Validation: Loss = 0.04161912\n",
      "Epoch 7: Loss = 0.03383306\n",
      "Validation: Loss = 0.04079314\n",
      "Epoch 8: Loss = 0.03312435\n",
      "Validation: Loss = 0.04058100\n",
      "Epoch 9: Loss = 0.03290557\n",
      "Validation: Loss = 0.04053917\n",
      "Epoch 10: Loss = 0.03282748\n",
      "Validation: Loss = 0.04051623\n",
      "Epoch 11: Loss = 0.03278319\n",
      "Validation: Loss = 0.04048735\n",
      "Epoch 12: Loss = 0.03274811\n",
      "Validation: Loss = 0.04045486\n",
      "Epoch 13: Loss = 0.03271667\n",
      "Validation: Loss = 0.04042253\n",
      "Epoch 14: Loss = 0.03268705\n",
      "Validation: Loss = 0.04039240\n",
      "Epoch 15: Loss = 0.03265838\n",
      "Validation: Loss = 0.04036515\n",
      "Epoch 16: Loss = 0.03263033\n",
      "Validation: Loss = 0.04034091\n",
      "Epoch 17: Loss = 0.03260273\n",
      "Validation: Loss = 0.04031953\n",
      "Epoch 18: Loss = 0.03257557\n",
      "Validation: Loss = 0.04030075\n",
      "Epoch 19: Loss = 0.03254879\n",
      "Validation: Loss = 0.04028425\n",
      "Epoch 20: Loss = 0.03252235\n",
      "Validation: Loss = 0.04026979\n",
      "Epoch 21: Loss = 0.03249623\n",
      "Validation: Loss = 0.04025707\n",
      "Epoch 22: Loss = 0.03247035\n",
      "Validation: Loss = 0.04024592\n",
      "Epoch 23: Loss = 0.03244461\n",
      "Validation: Loss = 0.04023613\n",
      "Epoch 24: Loss = 0.03241897\n",
      "Validation: Loss = 0.04022751\n",
      "Epoch 25: Loss = 0.03239328\n",
      "Validation: Loss = 0.04021996\n",
      "Epoch 26: Loss = 0.03236746\n",
      "Validation: Loss = 0.04021320\n",
      "Epoch 27: Loss = 0.03234150\n",
      "Validation: Loss = 0.04020707\n",
      "Epoch 28: Loss = 0.03231532\n",
      "Validation: Loss = 0.04020137\n",
      "Epoch 29: Loss = 0.03228870\n",
      "Validation: Loss = 0.04019587\n",
      "Epoch 30: Loss = 0.03226147\n",
      "Validation: Loss = 0.04019042\n",
      "\n",
      "\n",
      "\n",
      "Optimization ended.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_size=1\n",
    "hidden_size=24\n",
    "num_layers=2\n",
    "lstm=LSTM(input_size,hidden_size)\n",
    "\n",
    "learning_rate=0.0001\n",
    "max_grad_norm=5\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(lstm.parameters(), lr=learning_rate,weight_decay=0.000001)\n",
    "\n",
    "batch_size = 8\n",
    "num_epochs = 30 #3\n",
    "# num_sequences = x_train_set.size(0)\n",
    "# num_batches = num_sequences //batch_size\n",
    "\n",
    "checkpoint_freq = 10\n",
    "path = './'\n",
    "\n",
    "train_losses=[]\n",
    "valid_losses=[]\n",
    "\n",
    "print(\"Training model for {} epoch\".format(num_epochs))\n",
    "for epoch in range(num_epochs):\n",
    "#     total_loss = 0\n",
    "\n",
    "    # Shuffle input and target sequences.\n",
    "    idx = torch.randperm(x_train_set.size(0))\n",
    "    x = x_train_set[idx]\n",
    "    y = y_train_set[idx]\n",
    "    \n",
    "    train_loss=train(lstm,x_train_set,y_train_set,optimizer,batch_size,epoch)\n",
    "    valid_loss=eval(lstm,x_valid_set,y_valid_set,optimizer,batch_size)\n",
    "    \n",
    "    train_losses.append(train_loss)\n",
    "    valid_losses.append(valid_loss)\n",
    "    \n",
    "    # Checkpoint\n",
    "    if epoch % checkpoint_freq ==0:\n",
    "        save_model(epoch, lstm, path)\n",
    "        \n",
    "# Last checkpoint\n",
    "save_model(num_epochs, lstm, path)\n",
    "    \n",
    "print(\"\\n\\n\\nOptimization ended.\\n\")\n",
    "\n",
    "plt.plot(train_losses, color=\"darkcyan\", label=\"train\")\n",
    "plt.plot(valid_losses, color=\"tomato\",label=\"validation\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_one_hour(model,x_valid_set,input_size,num_steps):\n",
    "    predictions=torch.zeros(num_steps)\n",
    "    for i, x in enumerate(x_valid_set):\n",
    "        hidden=model.init_hidden(1)\n",
    "        y_pred,_,_=model(x.contiguous().view(-1, 1, input_size),hidden)\n",
    "        predictions[i]=y_pred\n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_step_predictions = predict_one_hour(lstm, x_valid_set, input_size, y_valid_set.size(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(y_valid_set.data.numpy(),color='darkcyan')\n",
    "plt.plot(one_step_predictions.data.numpy(),color='tomato')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
